package com.ruoyi.system.service.impl;

import com.cyl.manager.ums.domain.entity.UserInfo;
import com.github.pagehelper.PageHelper;
import com.ruoyi.chat.domain.FhChatFriend;
import com.ruoyi.chat.mapper.FhChatFriendMapper;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.framework.config.LocalDataUtil;
import com.ruoyi.system.domain.FhUser;
import com.ruoyi.system.domain.FhUserDto;
import com.ruoyi.system.mapper.FhUserMapper;
import com.ruoyi.system.service.IFhUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.*;

/**
 * 用户控制Service业务层处理
 *
 * @author oy
 * @date 2024-11-12
 */
@Service
public class FhUserServiceImpl implements IFhUserService
{
    @Autowired
    private FhUserMapper fhUserMapper;

    @Autowired
    private FhChatFriendMapper fhChatFriendMapper;

    /**
     * 查询用户控制
     *
     * @param id 用户控制主键
     * @return 用户控制
     */
    @Override
    public FhUser selectFhUserById(Long id)
    {
        return fhUserMapper.selectFhUserById(id);
    }

    @Override
    public FhUser selectFhUserByphone(String phone)
    {
        return fhUserMapper.selectFhUserByphone(phone);
    }



    /**
     * 查询用户控制列表
     *
     * @param fhUser 用户控制
     * @return 用户控制
     */
    @Override
    public List<FhUser> selectFhUserList(FhUser fhUser)
    {
        return fhUserMapper.selectFhUserList(fhUser);
    }

    /**
     * 新增用户控制
     *
     * @param fhUser 用户控制
     * @return 结果
     */
    @Override
    public int insertFhUser(FhUser fhUser)
    {
        fhUser.setCreateTime(LocalDateTime.now());
        return fhUserMapper.insertFhUser(fhUser);
    }

    /**
     * 修改用户控制
     *
     * @param fhUser 用户控制
     * @return 结果
     */
    @Override
    public int updateFhUser(FhUser fhUser)
    {
//        fhUser.;
        return fhUserMapper.updateFhUser(fhUser);
    }

    /**
     * 批量删除用户控制
     *
     * @param ids 需要删除的用户控制主键
     * @return 结果
     */
    @Override
    public int deleteFhUserByIds(Long[] ids)
    {
        return fhUserMapper.deleteFhUserByIds(ids);
    }

    /**
     * 删除用户控制信息
     *
     * @param id 用户控制主键
     * @return 结果
     */
    @Override
    public int deleteFhUserById(Long id)
    {
        return fhUserMapper.deleteFhUserById(id);
    }

    @Override
    public List<FhUserDto> getUser(FhUserDto fhUserDto ,Pageable page) {
        if (page != null){
            PageHelper.startPage(page.getPageNumber() + 1, page.getPageSize());
        }
        //查询出所有用户
        List<FhUserDto> user = fhUserMapper.getUser(fhUserDto);
        UserInfo member = (UserInfo) LocalDataUtil.getVar(Constants.MEMBER_INFO);
        if (user  != null){
            for (FhUserDto fhUserDto1 : user) {
                //查询是否有关注过用户
                FhChatFriend attention = fhChatFriendMapper.getAttention(member.getId(),fhUserDto1.getId());
                if (attention != null){
                    //是否关注     0 未关注  1  已关注
                    fhUserDto1.setAttention("1");
                }else {
                    fhUserDto1.setAttention("0");
                }
                List<FhChatFriend> countRecommend = fhChatFriendMapper.getCountRecommend(fhUserDto1.getId());
                fhUserDto1.setCountRecommend(countRecommend.size());
            }
        }
        return user;
    }

    @Override
    public List<FhUserDto> recommendFriend(FhUserDto fhUserDto, Pageable page) {
        UserInfo member = (UserInfo) LocalDataUtil.getVar(Constants.MEMBER_INFO);
        if (member == null) {
            return Collections.emptyList();
        }

        // 1. 获取当前用户的所有好友（已关注的用户）
        List<FhChatFriend> myFriends = fhChatFriendMapper.selectFhChatFriendByUserId(member.getId());
        Set<Long> friendIds = new HashSet<>();
        if (myFriends != null && !myFriends.isEmpty()) {
            for (FhChatFriend friend : myFriends) {
                friendIds.add(friend.getFriendId());
            }
        }

        if (friendIds.isEmpty()) {
            return Collections.emptyList();
        }

        // 2. 获取这些好友关注的人（即：每个好友的“关注列表”）
        Set<Long> recommendedUserIds = new HashSet<>();

        for (Long friendId : friendIds) {
            List<FhChatFriend> friendsOfFriend = fhChatFriendMapper.selectFhChatFriendByUserId(friendId);
            if (friendsOfFriend != null && !friendsOfFriend.isEmpty()) {
                for (FhChatFriend fof : friendsOfFriend) {
                    Long userId = fof.getFriendId();
                    if (!userId.equals(member.getId())) { // 排除自己
                        recommendedUserIds.add(userId);
                    }
                }
            }
        }

        if (recommendedUserIds.isEmpty()) {
            return Collections.emptyList();
        }

        // 3. 分页处理
        List<Long> userIds = new ArrayList<>(recommendedUserIds);
        int total = userIds.size();

        if (page != null) {
            PageHelper.startPage(page.getPageNumber() + 1, page.getPageSize());
            int start = Math.min(page.getPageNumber() * page.getPageSize(), total);
            int end = Math.min(start + page.getPageSize(), total);
            userIds = userIds.subList(start, end);
        }

        // 4. 查询用户信息、是否已关注、被关注人数
        List<FhUserDto> result = new ArrayList<>();
        for (Long userId : userIds) {
            // 跳过自己
            if (userId.equals(member.getId())) {
                continue;
            }

            // 判断是否已经关注过该用户
            if (friendIds.contains(userId)) {
                continue; // 已经关注过，跳过
            }

            FhUserDto dto = fhUserMapper.selectFhUserId(userId);
            if (dto == null) continue;

            // 是否被当前用户关注（这部分可以省略，因为上面已经过滤）
            // FhChatFriend attention = fhChatFriendMapper.getAttention(member.getId(), userId);
            // dto.setAttention(attention != null ? "1" : "0");

            // 被关注人数
            List<FhChatFriend> recommendList = fhChatFriendMapper.getCountRecommend(userId);
            dto.setCountRecommend(recommendList != null ? recommendList.size() : 0);
            if (recommendList != null && !recommendList.isEmpty()) {
                dto.setFriendName(recommendList.get(0).getFriendName());
            }

            result.add(dto);
        }

        return result;

    }

    @Override
    public List<FhUserDto> communicateList(String userList) {
        if (userList == null || userList.trim().isEmpty()) {
            return Collections.emptyList();
        }

        // 1. 切割手机号字符串
        String[] phoneNumbers = userList.split(",");
        List<String> phoneNumberList = Arrays.asList(phoneNumbers);

        // 2. 查询用户信息
        List<FhUserDto> result = fhUserMapper.selectFhUsersByPhoneNumbers(phoneNumberList);

        if (result == null || result.isEmpty()) {
            return Collections.emptyList();
        }

        UserInfo member = (UserInfo) LocalDataUtil.getVar(Constants.MEMBER_INFO);

        // 3. 获取当前用户的已关注列表（用于判断是否已关注）
        Set<Long> friendIds = new HashSet<>();
        if (member != null) {
            List<FhChatFriend> myFriends = fhChatFriendMapper.selectFhChatFriendByUserId(member.getId());
            if (myFriends != null && !myFriends.isEmpty()) {
                for (FhChatFriend friend : myFriends) {
                    friendIds.add(friend.getFriendId());
                }
            }
        }

        // 4. 填充用户信息：是否关注、被关注人数
        for (FhUserDto dto : result) {
            // 设置是否已被当前用户关注
            if (member != null && friendIds.contains(dto.getId())) {
                dto.setAttention("1");
            } else {
                dto.setAttention("0");
            }

            // 查询该用户的被关注人数
            List<FhChatFriend> recommendList = fhChatFriendMapper.getCountRecommend(dto.getId());
            dto.setCountRecommend(recommendList != null ? recommendList.size() : 0);
        }

        return result;
    }
}
